// 图片处理器 JavaScript版本
// 提供更强大的异步图片处理功能，包括批量处理、自动重试、缓存等

const { convertCloudUrlAsync, convertCloudUrl, getTempFileURL } = require('./util');

const ENV_ID = 'cloud1-6g22e569b6b129d5';
const BASE_CLOUD_PATH = `cloud://${ENV_ID}.636c-cloud1-6g22e569b6b129d5-1380223701`;

// 图片URL映射表
const imageUrlMap = {
  // 首页卡片
  '/static/home/card0.png': `${BASE_CLOUD_PATH}/static/home/card0.png`,
  '/static/home/card1.png': `${BASE_CLOUD_PATH}/static/home/card1.png`,
  '/static/home/card2.png': `${BASE_CLOUD_PATH}/static/home/card2.png`,
  '/static/home/card3.png': `${BASE_CLOUD_PATH}/static/home/card3.png`,
  '/static/home/card4.png': `${BASE_CLOUD_PATH}/static/home/card4.png`,
  
  // 轮播图
  '/static/home/swiper0.png': `${BASE_CLOUD_PATH}/static/home/swiper0.png`,
  '/static/home/swiper1.png': `${BASE_CLOUD_PATH}/static/home/swiper1.png`,
  '/static/home/swiper2.png': `${BASE_CLOUD_PATH}/static/home/swiper2.png`,
  
  // 图标资源
  '/static/icon_wx.png': `${BASE_CLOUD_PATH}/static/icon_wx.png`,
  '/static/icon_qq.png': `${BASE_CLOUD_PATH}/static/icon_qq.png`,
  '/static/icon_doc.png': `${BASE_CLOUD_PATH}/static/icon_doc.png`,
  '/static/icon_map.png': `${BASE_CLOUD_PATH}/static/icon_map.png`,
  '/static/icon_td.png': `${BASE_CLOUD_PATH}/static/icon_td.png`,
  '/static/avatar1.png': `${BASE_CLOUD_PATH}/static/avatar1.png`,
  '/static/img_td.png': `${BASE_CLOUD_PATH}/static/img_td.png`,
  '/static/bg_navbar2.png': `${BASE_CLOUD_PATH}/static/bg_navbar2.png`,
  
  // 聊天头像
  '/static/chat/avatar-Sean.png': `${BASE_CLOUD_PATH}/static/chat/avatar-Sean.png`,
  '/static/chat/avatar-Mollymolly.png': `${BASE_CLOUD_PATH}/static/chat/avatar-Mollymolly.png`,
  '/static/chat/avatar-Andrew.png': `${BASE_CLOUD_PATH}/static/chat/avatar-Andrew.png`,
  '/static/chat/avatar-Kingdom.png': `${BASE_CLOUD_PATH}/static/chat/avatar-Kingdom.png`,
  '/static/chat/avatar-Paige.png': `${BASE_CLOUD_PATH}/static/chat/avatar-Paige.png`,
  
  // 示例图片
  '/static/image1.png': `${BASE_CLOUD_PATH}/static/image1.png`,
  '/static/image2.png': `${BASE_CLOUD_PATH}/static/image2.png`
};

// 临时URL缓存
const tempUrlCache = new Map();

/**
 * 处理单个图片URL（同步版本）
 * @param {string} url - 原始图片URL
 * @returns {string} - 处理后的图片URL
 */
function processImageUrl(url) {
  if (typeof url !== 'string' || url === '') {
    return '';
  }
  
  // 1. 如果已经是完整的云存储URL，直接返回
  if (url.startsWith('cloud://') || url.startsWith('@cloud://')) {
    return url;
  }
  
  // 2. 如果是HTTP/HTTPS URL，直接返回
  if (url.startsWith('http://') || url.startsWith('https://')) {
    return url;
  }
  
  // 3. 如果是相对路径，尝试从映射表中获取云存储URL
  if (imageUrlMap[url]) {
    return imageUrlMap[url];
  }
  
  // 4. 如果是以/static/开头的路径，自动转换为云存储URL
  if (url.startsWith('/static/')) {
    return `${BASE_CLOUD_PATH}${url}`;
  }
  
  // 5. 如果是以static/开头的路径（没有前导斜杠），自动添加并转换
  if (url.startsWith('static/')) {
    return `${BASE_CLOUD_PATH}/${url}`;
  }
  
  // 6. 其他情况，如果看起来像本地路径，也尝试转换为云存储URL
  if (url.startsWith('/') || url.startsWith('./') || url.startsWith('../')) {
    // 移除前导的相对路径符号
    const cleanUrl = url.replace(/^\.{0,2}\//, '');
    if (cleanUrl.startsWith('static/')) {
      return `${BASE_CLOUD_PATH}/${cleanUrl}`;
    }
  }
  
  // 7. 默认情况，直接返回原URL
  return url;
}

/**
 * 处理单个图片URL（异步版本，获取临时URL）
 * @param {string} url - 原始图片URL
 * @param {boolean} useCache - 是否使用缓存
 * @returns {Promise<string>} - 处理后的图片URL
 */
async function processImageUrlAsync(url, useCache = true) {
  if (typeof url !== 'string' || url === '') {
    return '';
  }
  
  // 先进行同步处理
  const processedUrl = processImageUrl(url);
  
  // 如果不是云存储URL，直接返回
  if (!processedUrl.startsWith('cloud://') && !processedUrl.startsWith('@cloud://')) {
    return processedUrl;
  }
  
  // 检查缓存
  if (useCache && tempUrlCache.has(processedUrl)) {
    const cached = tempUrlCache.get(processedUrl);
    // 检查缓存是否过期（临时URL通常有效期2小时）
    if (Date.now() - cached.timestamp < 1.5 * 60 * 60 * 1000) { // 1.5小时
      return cached.url;
    } else {
      tempUrlCache.delete(processedUrl);
    }
  }
  
  try {
    const tempUrl = await convertCloudUrlAsync(processedUrl);
    
    // 缓存结果
    if (useCache && tempUrl) {
      tempUrlCache.set(processedUrl, {
        url: tempUrl,
        timestamp: Date.now()
      });
    }
    
    return tempUrl || processedUrl;
  } catch (error) {
    console.error('获取临时URL失败:', error);
    // 返回云存储URL作为备用
    return processedUrl;
  }
}

/**
 * 批量处理图片URL数组（同步版本）
 * @param {Array} urls - 图片URL数组
 * @returns {Array} - 处理后的图片URL数组
 */
function processImageUrls(urls) {
  if (!Array.isArray(urls)) {
    return [];
  }
  
  return urls.map(url => processImageUrl(url));
}

/**
 * 批量处理图片URL数组（异步版本）
 * @param {Array} urls - 图片URL数组
 * @param {boolean} useCache - 是否使用缓存
 * @returns {Promise<Array>} - 处理后的图片URL数组
 */
async function processImageUrlsAsync(urls, useCache = true) {
  if (!Array.isArray(urls)) {
    return [];
  }
  
  const promises = urls.map(url => processImageUrlAsync(url, useCache));
  
  try {
    return await Promise.all(promises);
  } catch (error) {
    console.error('批量处理图片URL失败:', error);
    // 如果批量处理失败，逐个处理
    const results = [];
    for (const url of urls) {
      try {
        const result = await processImageUrlAsync(url, useCache);
        results.push(result);
      } catch (err) {
        console.error(`处理图片URL失败: ${url}`, err);
        results.push(processImageUrl(url)); // 使用同步版本作为备用
      }
    }
    return results;
  }
}

/**
 * 处理对象中的图片URL字段
 * @param {Object} obj - 包含图片URL的对象
 * @param {Array<string>} fields - 需要处理的字段名数组
 * @param {boolean} async - 是否使用异步处理
 * @returns {Object|Promise<Object>} - 处理后的对象
 */
function processObjectImageUrls(obj, fields = ['url', 'image', 'src', 'avatar'], async = false) {
  if (!obj || typeof obj !== 'object') {
    return obj;
  }
  
  if (async) {
    return processObjectImageUrlsAsync(obj, fields);
  }
  
  const result = { ...obj };
  
  for (const field of fields) {
    if (result[field]) {
      if (Array.isArray(result[field])) {
        result[field] = processImageUrls(result[field]);
      } else if (typeof result[field] === 'string') {
        result[field] = processImageUrl(result[field]);
      }
    }
  }
  
  return result;
}

/**
 * 异步处理对象中的图片URL字段
 * @param {Object} obj - 包含图片URL的对象
 * @param {Array<string>} fields - 需要处理的字段名数组
 * @returns {Promise<Object>} - 处理后的对象
 */
async function processObjectImageUrlsAsync(obj, fields = ['url', 'image', 'src', 'avatar']) {
  if (!obj || typeof obj !== 'object') {
    return obj;
  }
  
  const result = { ...obj };
  
  for (const field of fields) {
    if (result[field]) {
      if (Array.isArray(result[field])) {
        result[field] = await processImageUrlsAsync(result[field]);
      } else if (typeof result[field] === 'string') {
        result[field] = await processImageUrlAsync(result[field]);
      }
    }
  }
  
  return result;
}

/**
 * 处理数组中对象的图片URL字段
 * @param {Array} arr - 对象数组
 * @param {Array<string>} fields - 需要处理的字段名数组
 * @param {boolean} async - 是否使用异步处理
 * @returns {Array|Promise<Array>} - 处理后的数组
 */
function processArrayImageUrls(arr, fields = ['url', 'image', 'src', 'avatar'], async = false) {
  if (!Array.isArray(arr)) {
    return arr;
  }
  
  if (async) {
    return Promise.all(arr.map(item => processObjectImageUrlsAsync(item, fields)));
  }
  
  return arr.map(item => processObjectImageUrls(item, fields, false));
}

/**
 * 清理缓存
 */
function clearCache() {
  tempUrlCache.clear();
}

/**
 * 获取缓存信息
 */
function getCacheInfo() {
  return {
    size: tempUrlCache.size,
    keys: Array.from(tempUrlCache.keys())
  };
}

/**
 * 添加新的图片URL映射
 * @param {string} originalUrl - 原始URL
 * @param {string} cloudUrl - 云存储URL
 */
function addImageMapping(originalUrl, cloudUrl) {
  imageUrlMap[originalUrl] = cloudUrl;
}

module.exports = {
  // 基础处理函数
  processImageUrl,
  processImageUrlAsync,
  processImageUrls,
  processImageUrlsAsync,
  
  // 对象处理函数
  processObjectImageUrls,
  processObjectImageUrlsAsync,
  processArrayImageUrls,
  
  // 工具函数
  clearCache,
  getCacheInfo,
  addImageMapping,
  
  // 常量
  ENV_ID,
  BASE_CLOUD_PATH,
  imageUrlMap
}; 